home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_jvm46.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  11.6 KB  |  647 lines

  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9. void se_msi38(void){
  10. ms134_473=se_ms(10,"to_integer");
  11. ms135_473=se_ms(10,"to_pointer");
  12. ms136_473=se_ms(7,"to_real");
  13. ms137_473=se_ms(12,"trace_switch");
  14. ms138_473=se_ms(20,"truncated_to_integer");
  15. ms139_473=se_ms(4,"twin");
  16. ms140_473=se_ms(5,"upper");
  17. ms141_473=se_ms(13,"with_capacity");
  18. ms142_473=se_ms(10,"write_byte");
  19. ms143_473=se_ms(7,"Current");
  20. ms144_473=se_ms(23,"NATIVE_ARRAY[CHARACTER]");
  21. ms145_473=se_ms(12,"like Current");
  22. ms146_473=se_ms(6,"Result");
  23. ms147_473=se_ms(4,"Void");
  24. ms1_473=se_ms(3,"ANY");
  25. ms10_393=se_ms(27,"Bad comment to end a class.");
  26. ms3_291=se_ms(27,"Cannot find Base Class for ");
  27. ms67_470=se_ms(1,".");
  28. ms1_683=se_ms(5,"Type ");
  29. ms19_605=se_ms(27,"Cyclic inheritance graph : ");
  30. }
  31. void se_msi39(void){
  32. ms20_605=se_ms(2,", ");
  33. ms21_605=se_ms(5,", ...");
  34. ms66_470=se_ms(16,"Class not found.");
  35. ms6_605=se_ms(56,"Deferred class should not have creation clause (VGCP.1).");
  36. ms2_683=se_ms(7,"Warning");
  37. ms10_604=se_ms(35,"Bad \"rename.se\" file.\nCannot open \"");
  38. ms137_470=se_ms(2,"\".");
  39. ms13_604=se_ms(9,"rename.se");
  40. ms14_604=se_ms(20,"Multiple entry for \"");
  41. ms15_604=se_ms(36,"\" in \"rename.se\" files.\nClash for \n\"");
  42. ms16_604=se_ms(8,"\" and \n\"");
  43. ms17_604=se_ms(2,".\n");
  44. ms25_364=se_ms(2,".e");
  45. ms11_604=se_ms(31,"Unable to find file for class \"");
  46. ms12_604=se_ms(3,"\". ");
  47. ms62_604=se_ms(19,"\nLoading path is :\n");
  48. ms2_604=se_ms(11,"loadpath.se");
  49. ms3_604=se_ms(9,"loadpath.");
  50. ms4_604=se_ms(23,"No default path (file \"");
  51. }
  52. void se_msi40(void){
  53. ms5_604=se_ms(14,"\" not found).\n");
  54. ms63_604=se_ms(22,"Environment Variable \"");
  55. ms64_604=se_ms(5,"\" is\n");
  56. ms66_604=se_ms(8,"set to \"");
  57. ms67_604=se_ms(3,"\". ");
  58. ms65_604=se_ms(9,"not set. ");
  59. ms7_604=se_ms(21,"Unable to load class.");
  60. ms6_604=se_ms(34,"Internal Error #1 in SMALL_EIFFEL.");
  61. ms9_627=se_ms(37,"SmallEiffel cannot load base class : ");
  62. ms10_627=se_ms(1,"\n");
  63. ms8_627=se_ms(2,"^\n");
  64. ms7_683=se_ms(7,"------\n");
  65. ms3_473=se_ms(3,"BIT");
  66. ms171_470=se_ms(3,"out");
  67. ms157_470=se_ms(19,"java/io/PrintStream");
  68. ms174_470=se_ms(5,"close");
  69. ms161_470=se_ms(3,"()V");
  70. ms168_470=se_ms(16,"java/lang/System");
  71. ms175_470=se_ms(3,"err");
  72. ms172_470=se_ms(21,"Ljava/io/PrintStream;");
  73. }
  74. void se_msi41(void){
  75. ms4_228=se_ms(4,"\312""\376""\272""\276""");
  76. ms5_228=se_ms(2,"\0""-");
  77. ms3_95=se_ms(15,"Constant pool: ");
  78. ms1_543=se_ms(5,"field");
  79. ms1_506=se_ms(6,"method");
  80. ms3_228=se_ms(4,"byte");
  81. ms8_306=se_ms(3,"No ");
  82. ms6_306=se_ms(6,"Total ");
  83. ms7_306=se_ms(2,": ");
  84. ms241_470=se_ms(2,".\n");
  85. ms1_632=se_ms(37,"Bad use of command `compile_to_jvm\'.\n");
  86. ms2_632=se_ms(14,"compile_to_jvm");
  87. ms2_364=se_ms(3,"man");
  88. ms126_470=se_ms(3,"sys");
  89. ms3_306=se_ms(18,"Try to read file \"");
  90. ms4_306=se_ms(3,"\".\n");
  91. ms20_364=se_ms(21,"Unable to find file\n\"");
  92. ms127_470=se_ms(9,"system.se");
  93. }
  94. void se_msi42(void){
  95. ms21_364=se_ms(14,"\" using path \"");
  96. ms121_470=se_ms(11,"SmallEiffel");
  97. ms1_364=se_ms(31,"/usr/local/logiciel/SmallEiffel");
  98. ms24_364=se_ms(11,"System is \"");
  99. ms22_364=se_ms(29,"Unknown system name in file\n\"");
  100. ms23_364=se_ms(36,"\".\nCurrently handled system names :\n");
  101. ms13_364=se_ms(5,"Amiga");
  102. ms14_364=se_ms(3,"DOS");
  103. ms15_364=se_ms(9,"Macintosh");
  104. ms16_364=se_ms(3,"OS2");
  105. ms18_364=se_ms(3,"VMS");
  106. ms19_364=se_ms(7,"Windows");
  107. ms17_364=se_ms(4,"UNIX");
  108. ms39_364=se_ms(4,".txt");
  109. ms3_364=se_ms(26,"Unable to find help file \"");
  110. ms242_470=se_ms(3,"\".\n");
  111. }
  112. T7*se_ms(int c,char*e){
  113. T7*s=malloc(sizeof(T7));
  114. s->_count=c;
  115. s->_capacity=c+1;
  116. s->_storage=malloc(c+1);
  117. memcpy(s->_storage,e,c);
  118. return s;}
  119. T7*e2s(char*e){
  120. return se_ms(strlen(e),e);}
  121. char*s2e(T7*s){
  122. char*e=malloc(1+s->_count);
  123. memcpy(e,s->_storage,s->_count);
  124. e[s->_count]='\0';
  125. return e;}
  126. void*se_ma65(int argc,...){
  127. T65*m;
  128. va_list pa;
  129. T0**s;
  130. m=malloc(sizeof(*m));
  131. *m=M65;
  132. if(argc){
  133. s=malloc(argc*sizeof(*s));
  134. m->_storage=s;
  135. m->_capacity=argc;
  136. m->_lower=1;
  137. m->_upper=argc;
  138. va_start(pa,argc);
  139. while(argc--){
  140. *(s++)=((void*)(va_arg(pa,char*)));
  141. }
  142. va_end(pa);
  143. }
  144. return m;}
  145. void*se_ma901(int argc,...){
  146. T901*m;
  147. va_list pa;
  148. T0**s;
  149. m=malloc(sizeof(*m));
  150. *m=M901;
  151. if(argc){
  152. s=malloc(argc*sizeof(*s));
  153. m->_storage=s;
  154. m->_capacity=argc;
  155. m->_lower=1;
  156. m->_upper=argc;
  157. va_start(pa,argc);
  158. while(argc--){
  159. *(s++)=((void*)(va_arg(pa,char*)));
  160. }
  161. va_end(pa);
  162. }
  163. return m;}
  164. void*se_ma263(int argc,...){
  165. T263*m;
  166. va_list pa;
  167. T0**s;
  168. m=malloc(sizeof(*m));
  169. *m=M263;
  170. if(argc){
  171. s=malloc(argc*sizeof(*s));
  172. m->_storage=s;
  173. m->_capacity=argc;
  174. m->_lower=1;
  175. m->_upper=argc;
  176. va_start(pa,argc);
  177. while(argc--){
  178. *(s++)=((void*)(va_arg(pa,char*)));
  179. }
  180. va_end(pa);
  181. }
  182. return m;}
  183. void*se_ma522(int argc,...){
  184. T522*m;
  185. va_list pa;
  186. T0**s;
  187. m=malloc(sizeof(*m));
  188. *m=M522;
  189. if(argc){
  190. s=malloc(argc*sizeof(*s));
  191. m->_storage=s;
  192. m->_capacity=argc;
  193. m->_lower=1;
  194. m->_upper=argc;
  195. va_start(pa,argc);
  196. while(argc--){
  197. *(s++)=((void*)(va_arg(pa,char*)));
  198. }
  199. va_end(pa);
  200. }
  201. return m;}
  202. void*se_ma587(int argc,...){
  203. T587*m;
  204. va_list pa;
  205. T0**s;
  206. m=malloc(sizeof(*m));
  207. *m=M587;
  208. if(argc){
  209. s=malloc(argc*sizeof(*s));
  210. m->_storage=s;
  211. m->_capacity=argc;
  212. m->_lower=1;
  213. m->_upper=argc;
  214. va_start(pa,argc);
  215. while(argc--){
  216. *(s++)=((void*)(va_arg(pa,char*)));
  217. }
  218. va_end(pa);
  219. }
  220. return m;}
  221. void*se_ma396(int argc,...){
  222. T396*m;
  223. va_list pa;
  224. T0**s;
  225. m=malloc(sizeof(*m));
  226. *m=M396;
  227. if(argc){
  228. s=malloc(argc*sizeof(*s));
  229. m->_storage=s;
  230. m->_capacity=argc;
  231. m->_lower=1;
  232. m->_upper=argc;
  233. va_start(pa,argc);
  234. while(argc--){
  235. *(s++)=((void*)(va_arg(pa,char*)));
  236. }
  237. va_end(pa);
  238. }
  239. return m;}
  240. void*se_ma848(int argc,...){
  241. T848*m;
  242. va_list pa;
  243. T0**s;
  244. m=malloc(sizeof(*m));
  245. *m=M848;
  246. if(argc){
  247. s=malloc(argc*sizeof(*s));
  248. m->_storage=s;
  249. m->_capacity=argc;
  250. m->_lower=1;
  251. m->_upper=argc;
  252. va_start(pa,argc);
  253. while(argc--){
  254. *(s++)=((void*)(va_arg(pa,char*)));
  255. }
  256. va_end(pa);
  257. }
  258. return m;}
  259. void*se_ma147(int argc,...){
  260. T147*m;
  261. va_list pa;
  262. T0**s;
  263. m=malloc(sizeof(*m));
  264. *m=M147;
  265. if(argc){
  266. s=malloc(argc*sizeof(*s));
  267. m->_storage=s;
  268. m->_capacity=argc;
  269. m->_lower=1;
  270. m->_upper=argc;
  271. va_start(pa,argc);
  272. while(argc--){
  273. *(s++)=((void*)(va_arg(pa,char*)));
  274. }
  275. va_end(pa);
  276. }
  277. return m;}
  278. void*se_ma855(int argc,...){
  279. T855*m;
  280. va_list pa;
  281. T0**s;
  282. m=malloc(sizeof(*m));
  283. *m=M855;
  284. if(argc){
  285. s=malloc(argc*sizeof(*s));
  286. m->_storage=s;
  287. m->_capacity=argc;
  288. m->_lower=1;
  289. m->_upper=argc;
  290. va_start(pa,argc);
  291. while(argc--){
  292. *(s++)=((void*)(va_arg(pa,char*)));
  293. }
  294. va_end(pa);
  295. }
  296. return m;}
  297. void*se_ma280(int argc,...){
  298. T280*m;
  299. va_list pa;
  300. T0**s;
  301. m=malloc(sizeof(*m));
  302. *m=M280;
  303. if(argc){
  304. s=malloc(argc*sizeof(*s));
  305. m->_storage=s;
  306. m->_capacity=argc;
  307. m->_lower=1;
  308. m->_upper=argc;
  309. va_start(pa,argc);
  310. while(argc--){
  311. *(s++)=((void*)(va_arg(pa,char*)));
  312. }
  313. va_end(pa);
  314. }
  315. return m;}
  316. void*se_ma26(int argc,...){
  317. T26*m;
  318. va_list pa;
  319. T0**s;
  320. m=malloc(sizeof(*m));
  321. *m=M26;
  322. if(argc){
  323. s=malloc(argc*sizeof(*s));
  324. m->_storage=s;
  325. m->_capacity=argc;
  326. m->_lower=1;
  327. m->_upper=argc;
  328. va_start(pa,argc);
  329. while(argc--){
  330. *(s++)=((void*)(va_arg(pa,char*)));
  331. }
  332. va_end(pa);
  333. }
  334. return m;}
  335. void*se_ma733(int argc,...){
  336. T733*m;
  337. va_list pa;
  338. T0**s;
  339. m=malloc(sizeof(*m));
  340. *m=M733;
  341. if(argc){
  342. s=malloc(argc*sizeof(*s));
  343. m->_storage=s;
  344. m->_capacity=argc;
  345. m->_lower=1;
  346. m->_upper=argc;
  347. va_start(pa,argc);
  348. while(argc--){
  349. *(s++)=((void*)(va_arg(pa,char*)));
  350. }
  351. va_end(pa);
  352. }
  353. return m;}
  354. void*se_ma96(int argc,...){
  355. T96*m;
  356. va_list pa;
  357. T0**s;
  358. m=malloc(sizeof(*m));
  359. *m=M96;
  360. if(argc){
  361. s=malloc(argc*sizeof(*s));
  362. m->_storage=s;
  363. m->_capacity=argc;
  364. m->_lower=1;
  365. m->_upper=argc;
  366. va_start(pa,argc);
  367. while(argc--){
  368. *(s++)=((void*)(va_arg(pa,char*)));
  369. }
  370. va_end(pa);
  371. }
  372. return m;}
  373. void*se_ma608(int argc,...){
  374. T608*m;
  375. va_list pa;
  376. T0**s;
  377. m=malloc(sizeof(*m));
  378. *m=M608;
  379. if(argc){
  380. s=malloc(argc*sizeof(*s));
  381. m->_storage=s;
  382. m->_capacity=argc;
  383. m->_lower=1;
  384. m->_upper=argc;
  385. va_start(pa,argc);
  386. while(argc--){
  387. *(s++)=((void*)(va_arg(pa,char*)));
  388. }
  389. va_end(pa);
  390. }
  391. return m;}
  392. void*se_ma419(int argc,...){
  393. T419*m;
  394. va_list pa;
  395. T0**s;
  396. m=malloc(sizeof(*m));
  397. *m=M419;
  398. if(argc){
  399. s=malloc(argc*sizeof(*s));
  400. m->_storage=s;
  401. m->_capacity=argc;
  402. m->_lower=1;
  403. m->_upper=argc;
  404. va_start(pa,argc);
  405. while(argc--){
  406. *(s++)=((void*)(va_arg(pa,char*)));
  407. }
  408. va_end(pa);
  409. }
  410. return m;}
  411. void*se_ma552(int argc,...){
  412. T552*m;
  413. va_list pa;
  414. T0**s;
  415. m=malloc(sizeof(*m));
  416. *m=M552;
  417. if(argc){
  418. s=malloc(argc*sizeof(*s));
  419. m->_storage=s;
  420. m->_capacity=argc;
  421. m->_lower=1;
  422. m->_upper=argc;
  423. va_start(pa,argc);
  424. while(argc--){
  425. *(s++)=((void*)(va_arg(pa,char*)));
  426. }
  427. va_end(pa);
  428. }
  429. return m;}
  430. void*se_ma681(int argc,...){
  431. T681*m;
  432. va_list pa;
  433. T0**s;
  434. m=malloc(sizeof(*m));
  435. *m=M681;
  436. if(argc){
  437. s=malloc(argc*sizeof(*s));
  438. m->_storage=s;
  439. m->_capacity=argc;
  440. m->_lower=1;
  441. m->_upper=argc;
  442. va_start(pa,argc);
  443. while(argc--){
  444. *(s++)=((void*)(va_arg(pa,char*)));
  445. }
  446. va_end(pa);
  447. }
  448. return m;}
  449. void*se_ma235(int argc,...){
  450. T235*m;
  451. va_list pa;
  452. T0**s;
  453. m=malloc(sizeof(*m));
  454. *m=M235;
  455. if(argc){
  456. s=malloc(argc*sizeof(*s));
  457. m->_storage=s;
  458. m->_capacity=argc;
  459. m->_lower=1;
  460. m->_upper=argc;
  461. va_start(pa,argc);
  462. while(argc--){
  463. *(s++)=((void*)(va_arg(pa,char*)));
  464. }
  465. va_end(pa);
  466. }
  467. return m;}
  468. void*se_ma429(int argc,...){
  469. T429*m;
  470. va_list pa;
  471. T2*s;
  472. m=malloc(sizeof(*m));
  473. *m=M429;
  474. if(argc){
  475. s=malloc(argc*sizeof(*s));
  476. m->_storage=s;
  477. m->_capacity=argc;
  478. m->_lower=1;
  479. m->_upper=argc;
  480. va_start(pa,argc);
  481. while(argc--){
  482. *(s++)=va_arg(pa,int);
  483. }
  484. va_end(pa);
  485. }
  486. return m;}
  487. void*se_ma495(int argc,...){
  488. T495*m;
  489. va_list pa;
  490. T0**s;
  491. m=malloc(sizeof(*m));
  492. *m=M495;
  493. if(argc){
  494. s=malloc(argc*sizeof(*s));
  495. m->_storage=s;
  496. m->_capacity=argc;
  497. m->_lower=1;
  498. m->_upper=argc;
  499. va_start(pa,argc);
  500. while(argc--){
  501. *(s++)=((void*)(va_arg(pa,char*)));
  502. }
  503. va_end(pa);
  504. }
  505. return m;}
  506. void*se_ma948(int argc,...){
  507. T948*m;
  508. va_list pa;
  509. T0**s;
  510. m=malloc(sizeof(*m));
  511. *m=M948;
  512. if(argc){
  513. s=malloc(argc*sizeof(*s));
  514. m->_storage=s;
  515. m->_capacity=argc;
  516. m->_lower=1;
  517. m->_upper=argc;
  518. va_start(pa,argc);
  519. while(argc--){
  520. *(s++)=((void*)(va_arg(pa,char*)));
  521. }
  522. va_end(pa);
  523. }
  524. return m;}
  525. void*se_ma52(int argc,...){
  526. T52*m;
  527. va_list pa;
  528. T0**s;
  529. m=malloc(sizeof(*m));
  530. *m=M52;
  531. if(argc){
  532. s=malloc(argc*sizeof(*s));
  533. m->_storage=s;
  534. m->_capacity=argc;
  535. m->_lower=1;
  536. m->_upper=argc;
  537. va_start(pa,argc);
  538. while(argc--){
  539. *(s++)=((void*)(va_arg(pa,char*)));
  540. }
  541. va_end(pa);
  542. }
  543. return m;}
  544. void*se_ma247(int argc,...){
  545. T247*m;
  546. va_list pa;
  547. T0**s;
  548. m=malloc(sizeof(*m));
  549. *m=M247;
  550. if(argc){
  551. s=malloc(argc*sizeof(*s));
  552. m->_storage=s;
  553. m->_capacity=argc;
  554. m->_lower=1;
  555. m->_upper=argc;
  556. va_start(pa,argc);
  557. while(argc--){
  558. *(s++)=((void*)(va_arg(pa,char*)));
  559. }
  560. va_end(pa);
  561. }
  562. return m;}
  563. void*se_ma764(int argc,...){
  564. T764*m;
  565. va_list pa;
  566. T0**s;
  567. m=malloc(sizeof(*m));
  568. *m=M764;
  569. if(argc){
  570. s=malloc(argc*sizeof(*s));
  571. m->_storage=s;
  572. m->_capacity=argc;
  573. m->_lower=1;
  574. m->_upper=argc;
  575. va_start(pa,argc);
  576. while(argc--){
  577. *(s++)=((void*)(va_arg(pa,char*)));
  578. }
  579. va_end(pa);
  580. }
  581. return m;}
  582. void*se_ma381(int argc,...){
  583. T381*m;
  584. va_list pa;
  585. T0**s;
  586. m=malloc(sizeof(*m));
  587. *m=M381;
  588. if(argc){
  589. s=malloc(argc*sizeof(*s));
  590. m->_storage=s;
  591. m->_capacity=argc;
  592. m->_lower=1;
  593. m->_upper=argc;
  594. va_start(pa,argc);
  595. while(argc--){
  596. *(s++)=((void*)(va_arg(pa,char*)));
  597. }
  598. va_end(pa);
  599. }
  600. return m;}
  601. void*se_ma701(int argc,...){
  602. T701*m;
  603. va_list pa;
  604. T0**s;
  605. m=malloc(sizeof(*m));
  606. *m=M701;
  607. if(argc){
  608. s=malloc(argc*sizeof(*s));
  609. m->_storage=s;
  610. m->_capacity=argc;
  611. m->_lower=1;
  612. m->_upper=argc;
  613. va_start(pa,argc);
  614. while(argc--){
  615. *(s++)=((void*)(va_arg(pa,char*)));
  616. }
  617. va_end(pa);
  618. }
  619. return m;}
  620. void*se_ma382(int argc,...){
  621. T382*m;
  622. va_list pa;
  623. T0**s;
  624. m=malloc(sizeof(*m));
  625. *m=M382;
  626. if(argc){
  627. s=malloc(argc*sizeof(*s));
  628. m->_storage=s;
  629. m->_capacity=argc;
  630. m->_lower=1;
  631. m->_upper=argc;
  632. va_start(pa,argc);
  633. while(argc--){
  634. *(s++)=((void*)(va_arg(pa,char*)));
  635. }
  636. va_end(pa);
  637. }
  638. return m;}
  639. void rsp(void){
  640. printf("Eiffel program crash at run time.\n");
  641. printf("No trace when using option \"-boost\"\n");}
  642. void sigrsp(int sig){
  643. printf("Received signal %d (man signal).\n",sig);
  644. rsp();
  645. exit(1);}
  646.  
  647.